home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / lib / python2.6 / compiler / ast.py < prev    next >
Text File  |  2009-11-02  |  36KB  |  1,361 lines
  1. """Python abstract syntax node definitions
  2.  
  3. This file is automatically generated by Tools/compiler/astgen.py
  4. """
  5. from compiler.consts import CO_VARARGS, CO_VARKEYWORDS
  6.  
  7. def flatten(seq):
  8.     l = []
  9.     for elt in seq:
  10.         t = type(elt)
  11.         if t is tuple or t is list:
  12.             for elt2 in flatten(elt):
  13.                 l.append(elt2)
  14.         else:
  15.             l.append(elt)
  16.     return l
  17.  
  18. def flatten_nodes(seq):
  19.     return [n for n in flatten(seq) if isinstance(n, Node)]
  20.  
  21. nodes = {}
  22.  
  23. class Node:
  24.     """Abstract base class for ast nodes."""
  25.     def getChildren(self):
  26.         pass # implemented by subclasses
  27.     def __iter__(self):
  28.         for n in self.getChildren():
  29.             yield n
  30.     def asList(self): # for backwards compatibility
  31.         return self.getChildren()
  32.     def getChildNodes(self):
  33.         pass # implemented by subclasses
  34.  
  35. class EmptyNode(Node):
  36.     pass
  37.  
  38. class Expression(Node):
  39.     # Expression is an artificial node class to support "eval"
  40.     nodes["expression"] = "Expression"
  41.     def __init__(self, node):
  42.         self.node = node
  43.  
  44.     def getChildren(self):
  45.         return self.node,
  46.  
  47.     def getChildNodes(self):
  48.         return self.node,
  49.  
  50.     def __repr__(self):
  51.         return "Expression(%s)" % (repr(self.node))
  52.  
  53. class Add(Node):
  54.     def __init__(self, (left, right), lineno=None):
  55.         self.left = left
  56.         self.right = right
  57.         self.lineno = lineno
  58.  
  59.     def getChildren(self):
  60.         return self.left, self.right
  61.  
  62.     def getChildNodes(self):
  63.         return self.left, self.right
  64.  
  65.     def __repr__(self):
  66.         return "Add((%s, %s))" % (repr(self.left), repr(self.right))
  67.  
  68. class And(Node):
  69.     def __init__(self, nodes, lineno=None):
  70.         self.nodes = nodes
  71.         self.lineno = lineno
  72.  
  73.     def getChildren(self):
  74.         return tuple(flatten(self.nodes))
  75.  
  76.     def getChildNodes(self):
  77.         nodelist = []
  78.         nodelist.extend(flatten_nodes(self.nodes))
  79.         return tuple(nodelist)
  80.  
  81.     def __repr__(self):
  82.         return "And(%s)" % (repr(self.nodes),)
  83.  
  84. class AssAttr(Node):
  85.     def __init__(self, expr, attrname, flags, lineno=None):
  86.         self.expr = expr
  87.         self.attrname = attrname
  88.         self.flags = flags
  89.         self.lineno = lineno
  90.  
  91.     def getChildren(self):
  92.         return self.expr, self.attrname, self.flags
  93.  
  94.     def getChildNodes(self):
  95.         return self.expr,
  96.  
  97.     def __repr__(self):
  98.         return "AssAttr(%s, %s, %s)" % (repr(self.expr), repr(self.attrname), repr(self.flags))
  99.  
  100. class AssList(Node):
  101.     def __init__(self, nodes, lineno=None):
  102.         self.nodes = nodes
  103.         self.lineno = lineno
  104.  
  105.     def getChildren(self):
  106.         return tuple(flatten(self.nodes))
  107.  
  108.     def getChildNodes(self):
  109.         nodelist = []
  110.         nodelist.extend(flatten_nodes(self.nodes))
  111.         return tuple(nodelist)
  112.  
  113.     def __repr__(self):
  114.         return "AssList(%s)" % (repr(self.nodes),)
  115.  
  116. class AssName(Node):
  117.     def __init__(self, name, flags, lineno=None):
  118.         self.name = name
  119.         self.flags = flags
  120.         self.lineno = lineno
  121.  
  122.     def getChildren(self):
  123.         return self.name, self.flags
  124.  
  125.     def getChildNodes(self):
  126.         return ()
  127.  
  128.     def __repr__(self):
  129.         return "AssName(%s, %s)" % (repr(self.name), repr(self.flags))
  130.  
  131. class AssTuple(Node):
  132.     def __init__(self, nodes, lineno=None):
  133.         self.nodes = nodes
  134.         self.lineno = lineno
  135.  
  136.     def getChildren(self):
  137.         return tuple(flatten(self.nodes))
  138.  
  139.     def getChildNodes(self):
  140.         nodelist = []
  141.         nodelist.extend(flatten_nodes(self.nodes))
  142.         return tuple(nodelist)
  143.  
  144.     def __repr__(self):
  145.         return "AssTuple(%s)" % (repr(self.nodes),)
  146.  
  147. class Assert(Node):
  148.     def __init__(self, test, fail, lineno=None):
  149.         self.test = test
  150.         self.fail = fail
  151.         self.lineno = lineno
  152.  
  153.     def getChildren(self):
  154.         children = []
  155.         children.append(self.test)
  156.         children.append(self.fail)
  157.         return tuple(children)
  158.  
  159.     def getChildNodes(self):
  160.         nodelist = []
  161.         nodelist.append(self.test)
  162.         if self.fail is not None:
  163.             nodelist.append(self.fail)
  164.         return tuple(nodelist)
  165.  
  166.     def __repr__(self):
  167.         return "Assert(%s, %s)" % (repr(self.test), repr(self.fail))
  168.  
  169. class Assign(Node):
  170.     def __init__(self, nodes, expr, lineno=None):
  171.         self.nodes = nodes
  172.         self.expr = expr
  173.         self.lineno = lineno
  174.  
  175.     def getChildren(self):
  176.         children = []
  177.         children.extend(flatten(self.nodes))
  178.         children.append(self.expr)
  179.         return tuple(children)
  180.  
  181.     def getChildNodes(self):
  182.         nodelist = []
  183.         nodelist.extend(flatten_nodes(self.nodes))
  184.         nodelist.append(self.expr)
  185.         return tuple(nodelist)
  186.  
  187.     def __repr__(self):
  188.         return "Assign(%s, %s)" % (repr(self.nodes), repr(self.expr))
  189.  
  190. class AugAssign(Node):
  191.     def __init__(self, node, op, expr, lineno=None):
  192.         self.node = node
  193.         self.op = op
  194.         self.expr = expr
  195.         self.lineno = lineno
  196.  
  197.     def getChildren(self):
  198.         return self.node, self.op, self.expr
  199.  
  200.     def getChildNodes(self):
  201.         return self.node, self.expr
  202.  
  203.     def __repr__(self):
  204.         return "AugAssign(%s, %s, %s)" % (repr(self.node), repr(self.op), repr(self.expr))
  205.  
  206. class Backquote(Node):
  207.     def __init__(self, expr, lineno=None):
  208.         self.expr = expr
  209.         self.lineno = lineno
  210.  
  211.     def getChildren(self):
  212.         return self.expr,
  213.  
  214.     def getChildNodes(self):
  215.         return self.expr,
  216.  
  217.     def __repr__(self):
  218.         return "Backquote(%s)" % (repr(self.expr),)
  219.  
  220. class Bitand(Node):
  221.     def __init__(self, nodes, lineno=None):
  222.         self.nodes = nodes
  223.         self.lineno = lineno
  224.  
  225.     def getChildren(self):
  226.         return tuple(flatten(self.nodes))
  227.  
  228.     def getChildNodes(self):
  229.         nodelist = []
  230.         nodelist.extend(flatten_nodes(self.nodes))
  231.         return tuple(nodelist)
  232.  
  233.     def __repr__(self):
  234.         return "Bitand(%s)" % (repr(self.nodes),)
  235.  
  236. class Bitor(Node):
  237.     def __init__(self, nodes, lineno=None):
  238.         self.nodes = nodes
  239.         self.lineno = lineno
  240.  
  241.     def getChildren(self):
  242.         return tuple(flatten(self.nodes))
  243.  
  244.     def getChildNodes(self):
  245.         nodelist = []
  246.         nodelist.extend(flatten_nodes(self.nodes))
  247.         return tuple(nodelist)
  248.  
  249.     def __repr__(self):
  250.         return "Bitor(%s)" % (repr(self.nodes),)
  251.  
  252. class Bitxor(Node):
  253.     def __init__(self, nodes, lineno=None):
  254.         self.nodes = nodes
  255.         self.lineno = lineno
  256.  
  257.     def getChildren(self):
  258.         return tuple(flatten(self.nodes))
  259.  
  260.     def getChildNodes(self):
  261.         nodelist = []
  262.         nodelist.extend(flatten_nodes(self.nodes))
  263.         return tuple(nodelist)
  264.  
  265.     def __repr__(self):
  266.         return "Bitxor(%s)" % (repr(self.nodes),)
  267.  
  268. class Break(Node):
  269.     def __init__(self, lineno=None):
  270.         self.lineno = lineno
  271.  
  272.     def getChildren(self):
  273.         return ()
  274.  
  275.     def getChildNodes(self):
  276.         return ()
  277.  
  278.     def __repr__(self):
  279.         return "Break()"
  280.  
  281. class CallFunc(Node):
  282.     def __init__(self, node, args, star_args = None, dstar_args = None, lineno=None):
  283.         self.node = node
  284.         self.args = args
  285.         self.star_args = star_args
  286.         self.dstar_args = dstar_args
  287.         self.lineno = lineno
  288.  
  289.     def getChildren(self):
  290.         children = []
  291.         children.append(self.node)
  292.         children.extend(flatten(self.args))
  293.         children.append(self.star_args)
  294.         children.append(self.dstar_args)
  295.         return tuple(children)
  296.  
  297.     def getChildNodes(self):
  298.         nodelist = []
  299.         nodelist.append(self.node)
  300.         nodelist.extend(flatten_nodes(self.args))
  301.         if self.star_args is not None:
  302.             nodelist.append(self.star_args)
  303.         if self.dstar_args is not None:
  304.             nodelist.append(self.dstar_args)
  305.         return tuple(nodelist)
  306.  
  307.     def __repr__(self):
  308.         return "CallFunc(%s, %s, %s, %s)" % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args))
  309.  
  310. class Class(Node):
  311.     def __init__(self, name, bases, doc, code, decorators = None, lineno=None):
  312.         self.name = name
  313.         self.bases = bases
  314.         self.doc = doc
  315.         self.code = code
  316.         self.decorators = decorators
  317.         self.lineno = lineno
  318.  
  319.     def getChildren(self):
  320.         children = []
  321.         children.append(self.name)
  322.         children.extend(flatten(self.bases))
  323.         children.append(self.doc)
  324.         children.append(self.code)
  325.         children.append(self.decorators)
  326.         return tuple(children)
  327.  
  328.     def getChildNodes(self):
  329.         nodelist = []
  330.         nodelist.extend(flatten_nodes(self.bases))
  331.         nodelist.append(self.code)
  332.         if self.decorators is not None:
  333.             nodelist.append(self.decorators)
  334.         return tuple(nodelist)
  335.  
  336.     def __repr__(self):
  337.         return "Class(%s, %s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code), repr(self.decorators))
  338.  
  339. class Compare(Node):
  340.     def __init__(self, expr, ops, lineno=None):
  341.         self.expr = expr
  342.         self.ops = ops
  343.         self.lineno = lineno
  344.  
  345.     def getChildren(self):
  346.         children = []
  347.         children.append(self.expr)
  348.         children.extend(flatten(self.ops))
  349.         return tuple(children)
  350.  
  351.     def getChildNodes(self):
  352.         nodelist = []
  353.         nodelist.append(self.expr)
  354.         nodelist.extend(flatten_nodes(self.ops))
  355.         return tuple(nodelist)
  356.  
  357.     def __repr__(self):
  358.         return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops))
  359.  
  360. class Const(Node):
  361.     def __init__(self, value, lineno=None):
  362.         self.value = value
  363.         self.lineno = lineno
  364.  
  365.     def getChildren(self):
  366.         return self.value,
  367.  
  368.     def getChildNodes(self):
  369.         return ()
  370.  
  371.     def __repr__(self):
  372.         return "Const(%s)" % (repr(self.value),)
  373.  
  374. class Continue(Node):
  375.     def __init__(self, lineno=None):
  376.         self.lineno = lineno
  377.  
  378.     def getChildren(self):
  379.         return ()
  380.  
  381.     def getChildNodes(self):
  382.         return ()
  383.  
  384.     def __repr__(self):
  385.         return "Continue()"
  386.  
  387. class Decorators(Node):
  388.     def __init__(self, nodes, lineno=None):
  389.         self.nodes = nodes
  390.         self.lineno = lineno
  391.  
  392.     def getChildren(self):
  393.         return tuple(flatten(self.nodes))
  394.  
  395.     def getChildNodes(self):
  396.         nodelist = []
  397.         nodelist.extend(flatten_nodes(self.nodes))
  398.         return tuple(nodelist)
  399.  
  400.     def __repr__(self):
  401.         return "Decorators(%s)" % (repr(self.nodes),)
  402.  
  403. class Dict(Node):
  404.     def __init__(self, items, lineno=None):
  405.         self.items = items
  406.         self.lineno = lineno
  407.  
  408.     def getChildren(self):
  409.         return tuple(flatten(self.items))
  410.  
  411.     def getChildNodes(self):
  412.         nodelist = []
  413.         nodelist.extend(flatten_nodes(self.items))
  414.         return tuple(nodelist)
  415.  
  416.     def __repr__(self):
  417.         return "Dict(%s)" % (repr(self.items),)
  418.  
  419. class Discard(Node):
  420.     def __init__(self, expr, lineno=None):
  421.         self.expr = expr
  422.         self.lineno = lineno
  423.  
  424.     def getChildren(self):
  425.         return self.expr,
  426.  
  427.     def getChildNodes(self):
  428.         return self.expr,
  429.  
  430.     def __repr__(self):
  431.         return "Discard(%s)" % (repr(self.expr),)
  432.  
  433. class Div(Node):
  434.     def __init__(self, (left, right), lineno=None):
  435.         self.left = left
  436.         self.right = right
  437.         self.lineno = lineno
  438.  
  439.     def getChildren(self):
  440.         return self.left, self.right
  441.  
  442.     def getChildNodes(self):
  443.         return self.left, self.right
  444.  
  445.     def __repr__(self):
  446.         return "Div((%s, %s))" % (repr(self.left), repr(self.right))
  447.  
  448. class Ellipsis(Node):
  449.     def __init__(self, lineno=None):
  450.         self.lineno = lineno
  451.  
  452.     def getChildren(self):
  453.         return ()
  454.  
  455.     def getChildNodes(self):
  456.         return ()
  457.  
  458.     def __repr__(self):
  459.         return "Ellipsis()"
  460.  
  461. class Exec(Node):
  462.     def __init__(self, expr, locals, globals, lineno=None):
  463.         self.expr = expr
  464.         self.locals = locals
  465.         self.globals = globals
  466.         self.lineno = lineno
  467.  
  468.     def getChildren(self):
  469.         children = []
  470.         children.append(self.expr)
  471.         children.append(self.locals)
  472.         children.append(self.globals)
  473.         return tuple(children)
  474.  
  475.     def getChildNodes(self):
  476.         nodelist = []
  477.         nodelist.append(self.expr)
  478.         if self.locals is not None:
  479.             nodelist.append(self.locals)
  480.         if self.globals is not None:
  481.             nodelist.append(self.globals)
  482.         return tuple(nodelist)
  483.  
  484.     def __repr__(self):
  485.         return "Exec(%s, %s, %s)" % (repr(self.expr), repr(self.locals), repr(self.globals))
  486.  
  487. class FloorDiv(Node):
  488.     def __init__(self, (left, right), lineno=None):
  489.         self.left = left
  490.         self.right = right
  491.         self.lineno = lineno
  492.  
  493.     def getChildren(self):
  494.         return self.left, self.right
  495.  
  496.     def getChildNodes(self):
  497.         return self.left, self.right
  498.  
  499.     def __repr__(self):
  500.         return "FloorDiv((%s, %s))" % (repr(self.left), repr(self.right))
  501.  
  502. class For(Node):
  503.     def __init__(self, assign, list, body, else_, lineno=None):
  504.         self.assign = assign
  505.         self.list = list
  506.         self.body = body
  507.         self.else_ = else_
  508.         self.lineno = lineno
  509.  
  510.     def getChildren(self):
  511.         children = []
  512.         children.append(self.assign)
  513.         children.append(self.list)
  514.         children.append(self.body)
  515.         children.append(self.else_)
  516.         return tuple(children)
  517.  
  518.     def getChildNodes(self):
  519.         nodelist = []
  520.         nodelist.append(self.assign)
  521.         nodelist.append(self.list)
  522.         nodelist.append(self.body)
  523.         if self.else_ is not None:
  524.             nodelist.append(self.else_)
  525.         return tuple(nodelist)
  526.  
  527.     def __repr__(self):
  528.         return "For(%s, %s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_))
  529.  
  530. class From(Node):
  531.     def __init__(self, modname, names, level, lineno=None):
  532.         self.modname = modname
  533.         self.names = names
  534.         self.level = level
  535.         self.lineno = lineno
  536.  
  537.     def getChildren(self):
  538.         return self.modname, self.names, self.level
  539.  
  540.     def getChildNodes(self):
  541.         return ()
  542.  
  543.     def __repr__(self):
  544.         return "From(%s, %s, %s)" % (repr(self.modname), repr(self.names), repr(self.level))
  545.  
  546. class Function(Node):
  547.     def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None):
  548.         self.decorators = decorators
  549.         self.name = name
  550.         self.argnames = argnames
  551.         self.defaults = defaults
  552.         self.flags = flags
  553.         self.doc = doc
  554.         self.code = code
  555.         self.lineno = lineno
  556.         self.varargs = self.kwargs = None
  557.         if flags & CO_VARARGS:
  558.             self.varargs = 1
  559.         if flags & CO_VARKEYWORDS:
  560.             self.kwargs = 1
  561.  
  562.  
  563.  
  564.     def getChildren(self):
  565.         children = []
  566.         children.append(self.decorators)
  567.         children.append(self.name)
  568.         children.append(self.argnames)
  569.         children.extend(flatten(self.defaults))
  570.         children.append(self.flags)
  571.         children.append(self.doc)
  572.         children.append(self.code)
  573.         return tuple(children)
  574.  
  575.     def getChildNodes(self):
  576.         nodelist = []
  577.         if self.decorators is not None:
  578.             nodelist.append(self.decorators)
  579.         nodelist.extend(flatten_nodes(self.defaults))
  580.         nodelist.append(self.code)
  581.         return tuple(nodelist)
  582.  
  583.     def __repr__(self):
  584.         return "Function(%s, %s, %s, %s, %s, %s, %s)" % (repr(self.decorators), repr(self.name), repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.doc), repr(self.code))
  585.  
  586. class GenExpr(Node):
  587.     def __init__(self, code, lineno=None):
  588.         self.code = code
  589.         self.lineno = lineno
  590.         self.argnames = ['.0']
  591.         self.varargs = self.kwargs = None
  592.  
  593.     def getChildren(self):
  594.         return self.code,
  595.  
  596.     def getChildNodes(self):
  597.         return self.code,
  598.  
  599.     def __repr__(self):
  600.         return "GenExpr(%s)" % (repr(self.code),)
  601.  
  602. class GenExprFor(Node):
  603.     def __init__(self, assign, iter, ifs, lineno=None):
  604.         self.assign = assign
  605.         self.iter = iter
  606.         self.ifs = ifs
  607.         self.lineno = lineno
  608.         self.is_outmost = False
  609.  
  610.  
  611.     def getChildren(self):
  612.         children = []
  613.         children.append(self.assign)
  614.         children.append(self.iter)
  615.         children.extend(flatten(self.ifs))
  616.         return tuple(children)
  617.  
  618.     def getChildNodes(self):
  619.         nodelist = []
  620.         nodelist.append(self.assign)
  621.         nodelist.append(self.iter)
  622.         nodelist.extend(flatten_nodes(self.ifs))
  623.         return tuple(nodelist)
  624.  
  625.     def __repr__(self):
  626.         return "GenExprFor(%s, %s, %s)" % (repr(self.assign), repr(self.iter), repr(self.ifs))
  627.  
  628. class GenExprIf(Node):
  629.     def __init__(self, test, lineno=None):
  630.         self.test = test
  631.         self.lineno = lineno
  632.  
  633.     def getChildren(self):
  634.         return self.test,
  635.  
  636.     def getChildNodes(self):
  637.         return self.test,
  638.  
  639.     def __repr__(self):
  640.         return "GenExprIf(%s)" % (repr(self.test),)
  641.  
  642. class GenExprInner(Node):
  643.     def __init__(self, expr, quals, lineno=None):
  644.         self.expr = expr
  645.         self.quals = quals
  646.         self.lineno = lineno
  647.  
  648.     def getChildren(self):
  649.         children = []
  650.         children.append(self.expr)
  651.         children.extend(flatten(self.quals))
  652.         return tuple(children)
  653.  
  654.     def getChildNodes(self):
  655.         nodelist = []
  656.         nodelist.append(self.expr)
  657.         nodelist.extend(flatten_nodes(self.quals))
  658.         return tuple(nodelist)
  659.  
  660.     def __repr__(self):
  661.         return "GenExprInner(%s, %s)" % (repr(self.expr), repr(self.quals))
  662.  
  663. class Getattr(Node):
  664.     def __init__(self, expr, attrname, lineno=None):
  665.         self.expr = expr
  666.         self.attrname = attrname
  667.         self.lineno = lineno
  668.  
  669.     def getChildren(self):
  670.         return self.expr, self.attrname
  671.  
  672.     def getChildNodes(self):
  673.         return self.expr,
  674.  
  675.     def __repr__(self):
  676.         return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname))
  677.  
  678. class Global(Node):
  679.     def __init__(self, names, lineno=None):
  680.         self.names = names
  681.         self.lineno = lineno
  682.  
  683.     def getChildren(self):
  684.         return self.names,
  685.  
  686.     def getChildNodes(self):
  687.         return ()
  688.  
  689.     def __repr__(self):
  690.         return "Global(%s)" % (repr(self.names),)
  691.  
  692. class If(Node):
  693.     def __init__(self, tests, else_, lineno=None):
  694.         self.tests = tests
  695.         self.else_ = else_
  696.         self.lineno = lineno
  697.  
  698.     def getChildren(self):
  699.         children = []
  700.         children.extend(flatten(self.tests))
  701.         children.append(self.else_)
  702.         return tuple(children)
  703.  
  704.     def getChildNodes(self):
  705.         nodelist = []
  706.         nodelist.extend(flatten_nodes(self.tests))
  707.         if self.else_ is not None:
  708.             nodelist.append(self.else_)
  709.         return tuple(nodelist)
  710.  
  711.     def __repr__(self):
  712.         return "If(%s, %s)" % (repr(self.tests), repr(self.else_))
  713.  
  714. class IfExp(Node):
  715.     def __init__(self, test, then, else_, lineno=None):
  716.         self.test = test
  717.         self.then = then
  718.         self.else_ = else_
  719.         self.lineno = lineno
  720.  
  721.     def getChildren(self):
  722.         return self.test, self.then, self.else_
  723.  
  724.     def getChildNodes(self):
  725.         return self.test, self.then, self.else_
  726.  
  727.     def __repr__(self):
  728.         return "IfExp(%s, %s, %s)" % (repr(self.test), repr(self.then), repr(self.else_))
  729.  
  730. class Import(Node):
  731.     def __init__(self, names, lineno=None):
  732.         self.names = names
  733.         self.lineno = lineno
  734.  
  735.     def getChildren(self):
  736.         return self.names,
  737.  
  738.     def getChildNodes(self):
  739.         return ()
  740.  
  741.     def __repr__(self):
  742.         return "Import(%s)" % (repr(self.names),)
  743.  
  744. class Invert(Node):
  745.     def __init__(self, expr, lineno=None):
  746.         self.expr = expr
  747.         self.lineno = lineno
  748.  
  749.     def getChildren(self):
  750.         return self.expr,
  751.  
  752.     def getChildNodes(self):
  753.         return self.expr,
  754.  
  755.     def __repr__(self):
  756.         return "Invert(%s)" % (repr(self.expr),)
  757.  
  758. class Keyword(Node):
  759.     def __init__(self, name, expr, lineno=None):
  760.         self.name = name
  761.         self.expr = expr
  762.         self.lineno = lineno
  763.  
  764.     def getChildren(self):
  765.         return self.name, self.expr
  766.  
  767.     def getChildNodes(self):
  768.         return self.expr,
  769.  
  770.     def __repr__(self):
  771.         return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr))
  772.  
  773. class Lambda(Node):
  774.     def __init__(self, argnames, defaults, flags, code, lineno=None):
  775.         self.argnames = argnames
  776.         self.defaults = defaults
  777.         self.flags = flags
  778.         self.code = code
  779.         self.lineno = lineno
  780.         self.varargs = self.kwargs = None
  781.         if flags & CO_VARARGS:
  782.             self.varargs = 1
  783.         if flags & CO_VARKEYWORDS:
  784.             self.kwargs = 1
  785.  
  786.  
  787.  
  788.     def getChildren(self):
  789.         children = []
  790.         children.append(self.argnames)
  791.         children.extend(flatten(self.defaults))
  792.         children.append(self.flags)
  793.         children.append(self.code)
  794.         return tuple(children)
  795.  
  796.     def getChildNodes(self):
  797.         nodelist = []
  798.         nodelist.extend(flatten_nodes(self.defaults))
  799.         nodelist.append(self.code)
  800.         return tuple(nodelist)
  801.  
  802.     def __repr__(self):
  803.         return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code))
  804.  
  805. class LeftShift(Node):
  806.     def __init__(self, (left, right), lineno=None):
  807.         self.left = left
  808.         self.right = right
  809.         self.lineno = lineno
  810.  
  811.     def getChildren(self):
  812.         return self.left, self.right
  813.  
  814.     def getChildNodes(self):
  815.         return self.left, self.right
  816.  
  817.     def __repr__(self):
  818.         return "LeftShift((%s, %s))" % (repr(self.left), repr(self.right))
  819.  
  820. class List(Node):
  821.     def __init__(self, nodes, lineno=None):
  822.         self.nodes = nodes
  823.         self.lineno = lineno
  824.  
  825.     def getChildren(self):
  826.         return tuple(flatten(self.nodes))
  827.  
  828.     def getChildNodes(self):
  829.         nodelist = []
  830.         nodelist.extend(flatten_nodes(self.nodes))
  831.         return tuple(nodelist)
  832.  
  833.     def __repr__(self):
  834.         return "List(%s)" % (repr(self.nodes),)
  835.  
  836. class ListComp(Node):
  837.     def __init__(self, expr, quals, lineno=None):
  838.         self.expr = expr
  839.         self.quals = quals
  840.         self.lineno = lineno
  841.  
  842.     def getChildren(self):
  843.         children = []
  844.         children.append(self.expr)
  845.         children.extend(flatten(self.quals))
  846.         return tuple(children)
  847.  
  848.     def getChildNodes(self):
  849.         nodelist = []
  850.         nodelist.append(self.expr)
  851.         nodelist.extend(flatten_nodes(self.quals))
  852.         return tuple(nodelist)
  853.  
  854.     def __repr__(self):
  855.         return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals))
  856.  
  857. class ListCompFor(Node):
  858.     def __init__(self, assign, list, ifs, lineno=None):
  859.         self.assign = assign
  860.         self.list = list
  861.         self.ifs = ifs
  862.         self.lineno = lineno
  863.  
  864.     def getChildren(self):
  865.         children = []
  866.         children.append(self.assign)
  867.         children.append(self.list)
  868.         children.extend(flatten(self.ifs))
  869.         return tuple(children)
  870.  
  871.     def getChildNodes(self):
  872.         nodelist = []
  873.         nodelist.append(self.assign)
  874.         nodelist.append(self.list)
  875.         nodelist.extend(flatten_nodes(self.ifs))
  876.         return tuple(nodelist)
  877.  
  878.     def __repr__(self):
  879.         return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs))
  880.  
  881. class ListCompIf(Node):
  882.     def __init__(self, test, lineno=None):
  883.         self.test = test
  884.         self.lineno = lineno
  885.  
  886.     def getChildren(self):
  887.         return self.test,
  888.  
  889.     def getChildNodes(self):
  890.         return self.test,
  891.  
  892.     def __repr__(self):
  893.         return "ListCompIf(%s)" % (repr(self.test),)
  894.  
  895. class Mod(Node):
  896.     def __init__(self, (left, right), lineno=None):
  897.         self.left = left
  898.         self.right = right
  899.         self.lineno = lineno
  900.  
  901.     def getChildren(self):
  902.         return self.left, self.right
  903.  
  904.     def getChildNodes(self):
  905.         return self.left, self.right
  906.  
  907.     def __repr__(self):
  908.         return "Mod((%s, %s))" % (repr(self.left), repr(self.right))
  909.  
  910. class Module(Node):
  911.     def __init__(self, doc, node, lineno=None):
  912.         self.doc = doc
  913.         self.node = node
  914.         self.lineno = lineno
  915.  
  916.     def getChildren(self):
  917.         return self.doc, self.node
  918.  
  919.     def getChildNodes(self):
  920.         return self.node,
  921.  
  922.     def __repr__(self):
  923.         return "Module(%s, %s)" % (repr(self.doc), repr(self.node))
  924.  
  925. class Mul(Node):
  926.     def __init__(self, (left, right), lineno=None):
  927.         self.left = left
  928.         self.right = right
  929.         self.lineno = lineno
  930.  
  931.     def getChildren(self):
  932.         return self.left, self.right
  933.  
  934.     def getChildNodes(self):
  935.         return self.left, self.right
  936.  
  937.     def __repr__(self):
  938.         return "Mul((%s, %s))" % (repr(self.left), repr(self.right))
  939.  
  940. class Name(Node):
  941.     def __init__(self, name, lineno=None):
  942.         self.name = name
  943.         self.lineno = lineno
  944.  
  945.     def getChildren(self):
  946.         return self.name,
  947.  
  948.     def getChildNodes(self):
  949.         return ()
  950.  
  951.     def __repr__(self):
  952.         return "Name(%s)" % (repr(self.name),)
  953.  
  954. class Not(Node):
  955.     def __init__(self, expr, lineno=None):
  956.         self.expr = expr
  957.         self.lineno = lineno
  958.  
  959.     def getChildren(self):
  960.         return self.expr,
  961.  
  962.     def getChildNodes(self):
  963.         return self.expr,
  964.  
  965.     def __repr__(self):
  966.         return "Not(%s)" % (repr(self.expr),)
  967.  
  968. class Or(Node):
  969.     def __init__(self, nodes, lineno=None):
  970.         self.nodes = nodes
  971.         self.lineno = lineno
  972.  
  973.     def getChildren(self):
  974.         return tuple(flatten(self.nodes))
  975.  
  976.     def getChildNodes(self):
  977.         nodelist = []
  978.         nodelist.extend(flatten_nodes(self.nodes))
  979.         return tuple(nodelist)
  980.  
  981.     def __repr__(self):
  982.         return "Or(%s)" % (repr(self.nodes),)
  983.  
  984. class Pass(Node):
  985.     def __init__(self, lineno=None):
  986.         self.lineno = lineno
  987.  
  988.     def getChildren(self):
  989.         return ()
  990.  
  991.     def getChildNodes(self):
  992.         return ()
  993.  
  994.     def __repr__(self):
  995.         return "Pass()"
  996.  
  997. class Power(Node):
  998.     def __init__(self, (left, right), lineno=None):
  999.         self.left = left
  1000.         self.right = right
  1001.         self.lineno = lineno
  1002.  
  1003.     def getChildren(self):
  1004.         return self.left, self.right
  1005.  
  1006.     def getChildNodes(self):
  1007.         return self.left, self.right
  1008.  
  1009.     def __repr__(self):
  1010.         return "Power((%s, %s))" % (repr(self.left), repr(self.right))
  1011.  
  1012. class Print(Node):
  1013.     def __init__(self, nodes, dest, lineno=None):
  1014.         self.nodes = nodes
  1015.         self.dest = dest
  1016.         self.lineno = lineno
  1017.  
  1018.     def getChildren(self):
  1019.         children = []
  1020.         children.extend(flatten(self.nodes))
  1021.         children.append(self.dest)
  1022.         return tuple(children)
  1023.  
  1024.     def getChildNodes(self):
  1025.         nodelist = []
  1026.         nodelist.extend(flatten_nodes(self.nodes))
  1027.         if self.dest is not None:
  1028.             nodelist.append(self.dest)
  1029.         return tuple(nodelist)
  1030.  
  1031.     def __repr__(self):
  1032.         return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest))
  1033.  
  1034. class Printnl(Node):
  1035.     def __init__(self, nodes, dest, lineno=None):
  1036.         self.nodes = nodes
  1037.         self.dest = dest
  1038.         self.lineno = lineno
  1039.  
  1040.     def getChildren(self):
  1041.         children = []
  1042.         children.extend(flatten(self.nodes))
  1043.         children.append(self.dest)
  1044.         return tuple(children)
  1045.  
  1046.     def getChildNodes(self):
  1047.         nodelist = []
  1048.         nodelist.extend(flatten_nodes(self.nodes))
  1049.         if self.dest is not None:
  1050.             nodelist.append(self.dest)
  1051.         return tuple(nodelist)
  1052.  
  1053.     def __repr__(self):
  1054.         return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest))
  1055.  
  1056. class Raise(Node):
  1057.     def __init__(self, expr1, expr2, expr3, lineno=None):
  1058.         self.expr1 = expr1
  1059.         self.expr2 = expr2
  1060.         self.expr3 = expr3
  1061.         self.lineno = lineno
  1062.  
  1063.     def getChildren(self):
  1064.         children = []
  1065.         children.append(self.expr1)
  1066.         children.append(self.expr2)
  1067.         children.append(self.expr3)
  1068.         return tuple(children)
  1069.  
  1070.     def getChildNodes(self):
  1071.         nodelist = []
  1072.         if self.expr1 is not None:
  1073.             nodelist.append(self.expr1)
  1074.         if self.expr2 is not None:
  1075.             nodelist.append(self.expr2)
  1076.         if self.expr3 is not None:
  1077.             nodelist.append(self.expr3)
  1078.         return tuple(nodelist)
  1079.  
  1080.     def __repr__(self):
  1081.         return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3))
  1082.  
  1083. class Return(Node):
  1084.     def __init__(self, value, lineno=None):
  1085.         self.value = value
  1086.         self.lineno = lineno
  1087.  
  1088.     def getChildren(self):
  1089.         return self.value,
  1090.  
  1091.     def getChildNodes(self):
  1092.         return self.value,
  1093.  
  1094.     def __repr__(self):
  1095.         return "Return(%s)" % (repr(self.value),)
  1096.  
  1097. class RightShift(Node):
  1098.     def __init__(self, (left, right), lineno=None):
  1099.         self.left = left
  1100.         self.right = right
  1101.         self.lineno = lineno
  1102.  
  1103.     def getChildren(self):
  1104.         return self.left, self.right
  1105.  
  1106.     def getChildNodes(self):
  1107.         return self.left, self.right
  1108.  
  1109.     def __repr__(self):
  1110.         return "RightShift((%s, %s))" % (repr(self.left), repr(self.right))
  1111.  
  1112. class Slice(Node):
  1113.     def __init__(self, expr, flags, lower, upper, lineno=None):
  1114.         self.expr = expr
  1115.         self.flags = flags
  1116.         self.lower = lower
  1117.         self.upper = upper
  1118.         self.lineno = lineno
  1119.  
  1120.     def getChildren(self):
  1121.         children = []
  1122.         children.append(self.expr)
  1123.         children.append(self.flags)
  1124.         children.append(self.lower)
  1125.         children.append(self.upper)
  1126.         return tuple(children)
  1127.  
  1128.     def getChildNodes(self):
  1129.         nodelist = []
  1130.         nodelist.append(self.expr)
  1131.         if self.lower is not None:
  1132.             nodelist.append(self.lower)
  1133.         if self.upper is not None:
  1134.             nodelist.append(self.upper)
  1135.         return tuple(nodelist)
  1136.  
  1137.     def __repr__(self):
  1138.         return "Slice(%s, %s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper))
  1139.  
  1140. class Sliceobj(Node):
  1141.     def __init__(self, nodes, lineno=None):
  1142.         self.nodes = nodes
  1143.         self.lineno = lineno
  1144.  
  1145.     def getChildren(self):
  1146.         return tuple(flatten(self.nodes))
  1147.  
  1148.     def getChildNodes(self):
  1149.         nodelist = []
  1150.         nodelist.extend(flatten_nodes(self.nodes))
  1151.         return tuple(nodelist)
  1152.  
  1153.     def __repr__(self):
  1154.         return "Sliceobj(%s)" % (repr(self.nodes),)
  1155.  
  1156. class Stmt(Node):
  1157.     def __init__(self, nodes, lineno=None):
  1158.         self.nodes = nodes
  1159.         self.lineno = lineno
  1160.  
  1161.     def getChildren(self):
  1162.         return tuple(flatten(self.nodes))
  1163.  
  1164.     def getChildNodes(self):
  1165.         nodelist = []
  1166.         nodelist.extend(flatten_nodes(self.nodes))
  1167.         return tuple(nodelist)
  1168.  
  1169.     def __repr__(self):
  1170.         return "Stmt(%s)" % (repr(self.nodes),)
  1171.  
  1172. class Sub(Node):
  1173.     def __init__(self, (left, right), lineno=None):
  1174.         self.left = left
  1175.         self.right = right
  1176.         self.lineno = lineno
  1177.  
  1178.     def getChildren(self):
  1179.         return self.left, self.right
  1180.  
  1181.     def getChildNodes(self):
  1182.         return self.left, self.right
  1183.  
  1184.     def __repr__(self):
  1185.         return "Sub((%s, %s))" % (repr(self.left), repr(self.right))
  1186.  
  1187. class Subscript(Node):
  1188.     def __init__(self, expr, flags, subs, lineno=None):
  1189.         self.expr = expr
  1190.         self.flags = flags
  1191.         self.subs = subs
  1192.         self.lineno = lineno
  1193.  
  1194.     def getChildren(self):
  1195.         children = []
  1196.         children.append(self.expr)
  1197.         children.append(self.flags)
  1198.         children.extend(flatten(self.subs))
  1199.         return tuple(children)
  1200.  
  1201.     def getChildNodes(self):
  1202.         nodelist = []
  1203.         nodelist.append(self.expr)
  1204.         nodelist.extend(flatten_nodes(self.subs))
  1205.         return tuple(nodelist)
  1206.  
  1207.     def __repr__(self):
  1208.         return "Subscript(%s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.subs))
  1209.  
  1210. class TryExcept(Node):
  1211.     def __init__(self, body, handlers, else_, lineno=None):
  1212.         self.body = body
  1213.         self.handlers = handlers
  1214.         self.else_ = else_
  1215.         self.lineno = lineno
  1216.  
  1217.     def getChildren(self):
  1218.         children = []
  1219.         children.append(self.body)
  1220.         children.extend(flatten(self.handlers))
  1221.         children.append(self.else_)
  1222.         return tuple(children)
  1223.  
  1224.     def getChildNodes(self):
  1225.         nodelist = []
  1226.         nodelist.append(self.body)
  1227.         nodelist.extend(flatten_nodes(self.handlers))
  1228.         if self.else_ is not None:
  1229.             nodelist.append(self.else_)
  1230.         return tuple(nodelist)
  1231.  
  1232.     def __repr__(self):
  1233.         return "TryExcept(%s, %s, %s)" % (repr(self.body), repr(self.handlers), repr(self.else_))
  1234.  
  1235. class TryFinally(Node):
  1236.     def __init__(self, body, final, lineno=None):
  1237.         self.body = body
  1238.         self.final = final
  1239.         self.lineno = lineno
  1240.  
  1241.     def getChildren(self):
  1242.         return self.body, self.final
  1243.  
  1244.     def getChildNodes(self):
  1245.         return self.body, self.final
  1246.  
  1247.     def __repr__(self):
  1248.         return "TryFinally(%s, %s)" % (repr(self.body), repr(self.final))
  1249.  
  1250. class Tuple(Node):
  1251.     def __init__(self, nodes, lineno=None):
  1252.         self.nodes = nodes
  1253.         self.lineno = lineno
  1254.  
  1255.     def getChildren(self):
  1256.         return tuple(flatten(self.nodes))
  1257.  
  1258.     def getChildNodes(self):
  1259.         nodelist = []
  1260.         nodelist.extend(flatten_nodes(self.nodes))
  1261.         return tuple(nodelist)
  1262.  
  1263.     def __repr__(self):
  1264.         return "Tuple(%s)" % (repr(self.nodes),)
  1265.  
  1266. class UnaryAdd(Node):
  1267.     def __init__(self, expr, lineno=None):
  1268.         self.expr = expr
  1269.         self.lineno = lineno
  1270.  
  1271.     def getChildren(self):
  1272.         return self.expr,
  1273.  
  1274.     def getChildNodes(self):
  1275.         return self.expr,
  1276.  
  1277.     def __repr__(self):
  1278.         return "UnaryAdd(%s)" % (repr(self.expr),)
  1279.  
  1280. class UnarySub(Node):
  1281.     def __init__(self, expr, lineno=None):
  1282.         self.expr = expr
  1283.         self.lineno = lineno
  1284.  
  1285.     def getChildren(self):
  1286.         return self.expr,
  1287.  
  1288.     def getChildNodes(self):
  1289.         return self.expr,
  1290.  
  1291.     def __repr__(self):
  1292.         return "UnarySub(%s)" % (repr(self.expr),)
  1293.  
  1294. class While(Node):
  1295.     def __init__(self, test, body, else_, lineno=None):
  1296.         self.test = test
  1297.         self.body = body
  1298.         self.else_ = else_
  1299.         self.lineno = lineno
  1300.  
  1301.     def getChildren(self):
  1302.         children = []
  1303.         children.append(self.test)
  1304.         children.append(self.body)
  1305.         children.append(self.else_)
  1306.         return tuple(children)
  1307.  
  1308.     def getChildNodes(self):
  1309.         nodelist = []
  1310.         nodelist.append(self.test)
  1311.         nodelist.append(self.body)
  1312.         if self.else_ is not None:
  1313.             nodelist.append(self.else_)
  1314.         return tuple(nodelist)
  1315.  
  1316.     def __repr__(self):
  1317.         return "While(%s, %s, %s)" % (repr(self.test), repr(self.body), repr(self.else_))
  1318.  
  1319. class With(Node):
  1320.     def __init__(self, expr, vars, body, lineno=None):
  1321.         self.expr = expr
  1322.         self.vars = vars
  1323.         self.body = body
  1324.         self.lineno = lineno
  1325.  
  1326.     def getChildren(self):
  1327.         children = []
  1328.         children.append(self.expr)
  1329.         children.append(self.vars)
  1330.         children.append(self.body)
  1331.         return tuple(children)
  1332.  
  1333.     def getChildNodes(self):
  1334.         nodelist = []
  1335.         nodelist.append(self.expr)
  1336.         if self.vars is not None:
  1337.             nodelist.append(self.vars)
  1338.         nodelist.append(self.body)
  1339.         return tuple(nodelist)
  1340.  
  1341.     def __repr__(self):
  1342.         return "With(%s, %s, %s)" % (repr(self.expr), repr(self.vars), repr(self.body))
  1343.  
  1344. class Yield(Node):
  1345.     def __init__(self, value, lineno=None):
  1346.         self.value = value
  1347.         self.lineno = lineno
  1348.  
  1349.     def getChildren(self):
  1350.         return self.value,
  1351.  
  1352.     def getChildNodes(self):
  1353.         return self.value,
  1354.  
  1355.     def __repr__(self):
  1356.         return "Yield(%s)" % (repr(self.value),)
  1357.  
  1358. for name, obj in globals().items():
  1359.     if isinstance(obj, type) and issubclass(obj, Node):
  1360.         nodes[name.lower()] = obj
  1361.